home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_xemacs.idb / usr / freeware / lib / xemacs-20.4 / info / gnus.info-5.z / gnus.info-5
Encoding:
GNU Info File  |  1998-05-21  |  47.4 KB  |  1,278 lines
  1. This is Info file ../info/gnus.info, produced by Makeinfo version 1.68
  2. from the input file gnus.texi.
  3.  
  4.    This file documents Gnus, the GNU Emacs newsreader.
  5.  
  6.    Copyright (C) 1995,96 Free Software Foundation, Inc.
  7.  
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.  
  12.    Permission is granted to copy and distribute modified versions of
  13. this manual under the conditions for verbatim copying, provided also
  14. that the entire resulting derived work is distributed under the terms
  15. of a permission notice identical to this one.
  16.  
  17.    Permission is granted to copy and distribute translations of this
  18. manual into another language, under the above conditions for modified
  19. versions.
  20.  
  21. 
  22. File: gnus.info,  Node: Crosspost Handling,  Next: Duplicate Suppression,  Prev: Exiting the Summary Buffer,  Up: The Summary Buffer
  23.  
  24. Crosspost Handling
  25. ==================
  26.  
  27.    Marking cross-posted articles as read ensures that you'll never have
  28. to read the same article more than once.  Unless, of course, somebody
  29. has posted it to several groups separately.  Posting the same article to
  30. several groups (not cross-posting) is called "spamming", and you are by
  31. law required to send nasty-grams to anyone who perpetrates such a
  32. heinous crime.  You may want to try NoCeM handling to filter out spam
  33. (*note NoCeM::.).
  34.  
  35.    Remember: Cross-posting is kinda ok, but posting the same article
  36. separately to several groups is not.  Massive cross-posting (aka.
  37. "velveeta") is to be avoided at all costs, and you can even use the
  38. `gnus-summary-mail-crosspost-complaint' command to complain about
  39. excessive crossposting (*note Summary Mail Commands::.).
  40.  
  41.    One thing that may cause Gnus to not do the cross-posting thing
  42. correctly is if you use an NNTP server that supports XOVER (which is
  43. very nice, because it speeds things up considerably) which does not
  44. include the `Xref' header in its NOV lines.  This is Evil, but all too
  45. common, alas, alack.  Gnus tries to Do The Right Thing even with XOVER
  46. by registering the `Xref' lines of all articles you actually read, but
  47. if you kill the articles, or just mark them as read without reading
  48. them, Gnus will not get a chance to snoop the `Xref' lines out of these
  49. articles, and will be unable to use the cross reference mechanism.
  50.  
  51.    To check whether your NNTP server includes the `Xref' header in its
  52. overview files, try `telnet your.nntp.server nntp', `MODE READER' on
  53. `inn' servers, and then say `LIST overview.fmt'.  This may not work,
  54. but if it does, and the last line you get does not read `Xref:full',
  55. then you should shout and whine at your news admin until she includes
  56. the `Xref' header in the overview files.
  57.  
  58.    If you want Gnus to get the `Xref's right all the time, you have to
  59. set `gnus-nov-is-evil' to `t', which slows things down considerably.
  60.  
  61.    C'est la vie.
  62.  
  63.    For an alternative approach, *note Duplicate Suppression::..
  64.  
  65. 
  66. File: gnus.info,  Node: Duplicate Suppression,  Prev: Crosspost Handling,  Up: The Summary Buffer
  67.  
  68. Duplicate Suppression
  69. =====================
  70.  
  71.    By default, Gnus tries to make sure that you don't have to read the
  72. same article more than once by utilizing the crossposting mechanism
  73. (*note Crosspost Handling::.).  However, that simple and efficient
  74. approach may not work satisfactory for some users for various reasons.
  75.  
  76.   1. The NNTP server may fail to generate the `Xref' header.  This is
  77.      evil and not very common.
  78.  
  79.   2. The NNTP server may fail to include the `Xref' header in the
  80.      `.overview' data bases.  This is evil and all too common, alas.
  81.  
  82.   3. You may be reading the same group (or several related groups) from
  83.      different NNTP servers.
  84.  
  85.   4. You may be getting mail that duplicates articles posted to groups.
  86.  
  87.    I'm sure there are other situations where `Xref' handling fails as
  88. well, but these four are the most common situations.
  89.  
  90.    If, and only if, `Xref' handling fails for you, then you may
  91. consider switching on "duplicate suppression".  If you do so, Gnus will
  92. remember the `Message-ID's of all articles you have read or otherwise
  93. marked as read, and then, as if by magic, mark them as read all
  94. subsequent times you see them--in *all* groups.  Using this mechanism
  95. is quite likely to be somewhat inefficient, but not overly so.  It's
  96. certainly preferable to reading the same articles more than once.
  97.  
  98.    Duplicate suppression is not a very subtle instrument.  It's more
  99. like a sledge hammer than anything else.  It works in a very simple
  100. fashion--if you have marked an article as read, it adds this Message-ID
  101. to a cache.  The next time it sees this Message-ID, it will mark the
  102. article as read with the `M' mark.  It doesn't care what group it saw
  103. the article in.
  104.  
  105. `gnus-suppress-duplicates'
  106.      If non-`nil', suppress duplicates.
  107.  
  108. `gnus-save-duplicate-list'
  109.      If non-`nil', save the list of duplicates to a file.  This will
  110.      make startup and shutdown take longer, so the default is `nil'.
  111.      However, this means that only duplicate articles read in a single
  112.      Gnus session are suppressed.
  113.  
  114. `gnus-duplicate-list-length'
  115.      This variable says how many `Message-ID's to keep in the duplicate
  116.      suppression list.  The default is 10000.
  117.  
  118. `gnus-duplicate-file'
  119.      The name of the file to store the duplicate suppression list in.
  120.      The default is `~/News/suppression'.
  121.  
  122.    If you have a tendency to stop and start Gnus often, setting
  123. `gnus-save-duplicate-list' to `t' is probably a good idea.  If you
  124. leave Gnus running for weeks on end, you may have it `nil'.  On the
  125. other hand, saving the list makes startup and shutdown much slower, so
  126. that means that if you stop and start Gnus often, you should set
  127. `gnus-save-duplicate-list' to `nil'.  Uhm.  I'll leave this up to you
  128. to figure out, I think.
  129.  
  130. 
  131. File: gnus.info,  Node: The Article Buffer,  Next: Composing Messages,  Prev: The Summary Buffer,  Up: Top
  132.  
  133. The Article Buffer
  134. ******************
  135.  
  136.    The articles are displayed in the article buffer, of which there is
  137. only one.  All the summary buffers share the same article buffer unless
  138. you tell Gnus otherwise.
  139.  
  140. * Menu:
  141.  
  142. * Hiding Headers::        Deciding what headers should be displayed.
  143. * Using MIME::            Pushing articles through MIME before reading them.
  144. * Customizing Articles::  Tailoring the look of the articles.
  145. * Article Keymap::        Keystrokes available in the article buffer.
  146. * Misc Article::          Other stuff.
  147.  
  148. 
  149. File: gnus.info,  Node: Hiding Headers,  Next: Using MIME,  Up: The Article Buffer
  150.  
  151. Hiding Headers
  152. ==============
  153.  
  154.    The top section of each article is the "head".  (The rest is the
  155. "body", but you may have guessed that already.)
  156.  
  157.    There is a lot of useful information in the head: the name of the
  158. person who wrote the article, the date it was written and the subject
  159. of the article.  That's well and nice, but there's also lots of
  160. information most people do not want to see--what systems the article
  161. has passed through before reaching you, the `Message-ID', the
  162. `References', etc. ad nauseum--and you'll probably want to get rid of
  163. some of those lines.  If you want to keep all those lines in the
  164. article buffer, you can set `gnus-show-all-headers' to `t'.
  165.  
  166.    Gnus provides you with two variables for sifting headers:
  167.  
  168. `gnus-visible-headers'
  169.      If this variable is non-`nil', it should be a regular expression
  170.      that says what headers you wish to keep in the article buffer.  All
  171.      headers that do not match this variable will be hidden.
  172.  
  173.      For instance, if you only want to see the name of the person who
  174.      wrote the article and the subject, you'd say:
  175.  
  176.           (setq gnus-visible-headers "^From:\\|^Subject:")
  177.  
  178.      This variable can also be a list of regexps to match headers to
  179.      remain visible.
  180.  
  181. `gnus-ignored-headers'
  182.      This variable is the reverse of `gnus-visible-headers'.  If this
  183.      variable is set (and `gnus-visible-headers' is `nil'), it should
  184.      be a regular expression that matches all lines that you want to
  185.      hide.  All lines that do not match this variable will remain
  186.      visible.
  187.  
  188.      For instance, if you just want to get rid of the `References' line
  189.      and the `Xref' line, you might say:
  190.  
  191.           (setq gnus-ignored-headers "^References:\\|^Xref:")
  192.  
  193.      This variable can also be a list of regexps to match headers to be
  194.      removed.
  195.  
  196.      Note that if `gnus-visible-headers' is non-`nil', this variable
  197.      will have no effect.
  198.  
  199.    Gnus can also sort the headers for you.  (It does this by default.)
  200. You can control the sorting by setting the `gnus-sorted-header-list'
  201. variable.  It is a list of regular expressions that says in what order
  202. the headers are to be displayed.
  203.  
  204.    For instance, if you want the name of the author of the article
  205. first, and then the subject, you might say something like:
  206.  
  207.      (setq gnus-sorted-header-list '("^From:" "^Subject:"))
  208.  
  209.    Any headers that are to remain visible, but are not listed in this
  210. variable, will be displayed in random order after all the headers
  211. listed in this variable.
  212.  
  213.    You can hide further boring headers by entering
  214. `gnus-article-hide-boring-headers' into `gnus-article-display-hook'.
  215. What this function does depends on the `gnus-boring-article-headers'
  216. variable.  It's a list, but this list doesn't actually contain header
  217. names.  Instead is lists various "boring conditions" that Gnus can
  218. check and remove from sight.
  219.  
  220.    These conditions are:
  221. `empty'
  222.      Remove all empty headers.
  223.  
  224. `newsgroups'
  225.      Remove the `Newsgroups' header if it only contains the current
  226.      group name.
  227.  
  228. `followup-to'
  229.      Remove the `Followup-To' header if it is identical to the
  230.      `Newsgroups' header.
  231.  
  232. `reply-to'
  233.      Remove the `Reply-To' header if it lists the same address as the
  234.      `From' header.
  235.  
  236. `date'
  237.      Remove the `Date' header if the article is less than three days
  238.      old.
  239.  
  240.    To include the four first elements, you could say something like;
  241.  
  242.      (setq gnus-boring-article-headers
  243.            '(empty newsgroups followup-to reply-to))
  244.  
  245.    This is also the default value for this variable.
  246.  
  247. 
  248. File: gnus.info,  Node: Using MIME,  Next: Customizing Articles,  Prev: Hiding Headers,  Up: The Article Buffer
  249.  
  250. Using MIME
  251. ==========
  252.  
  253.    Mime is a standard for waving your hands through the air, aimlessly,
  254. while people stand around yawning.
  255.  
  256.    MIME, however, is a standard for encoding your articles, aimlessly,
  257. while all newsreaders die of fear.
  258.  
  259.    MIME may specify what character set the article uses, the encoding
  260. of the characters, and it also makes it possible to embed pictures and
  261. other naughty stuff in innocent-looking articles.
  262.  
  263.    Gnus handles MIME by pushing the articles through
  264. `gnus-show-mime-method', which is `metamail-buffer' by default.  Set
  265. `gnus-show-mime' to `t' if you want to use MIME all the time.  However,
  266. if `gnus-strict-mime' is non-`nil', the MIME method will only be used
  267. if there are MIME headers in the article.  If you have `gnus-show-mime'
  268. set, then you'll see some unfortunate display glitches in the article
  269. buffer.  These can't be avoided.
  270.  
  271.    It might be best to just use the toggling functions from the summary
  272. buffer to avoid getting nasty surprises. (For instance, you enter the
  273. group `alt.sing-a-long' and, before you know it, MIME has decoded the
  274. sound file in the article and some horrible sing-a-long song comes
  275. screaming out your speakers, and you can't find the volume button,
  276. because there isn't one, and people are starting to look at you, and
  277. you try to stop the program, but you can't, and you can't find the
  278. program to control the volume, and everybody else in the room suddenly
  279. decides to look at you disdainfully, and you'll feel rather stupid.)
  280.  
  281.    Any similarity to real events and people is purely coincidental.
  282. Ahem.
  283.  
  284. 
  285. File: gnus.info,  Node: Customizing Articles,  Next: Article Keymap,  Prev: Using MIME,  Up: The Article Buffer
  286.  
  287. Customizing Articles
  288. ====================
  289.  
  290.    The `gnus-article-display-hook' is called after the article has been
  291. inserted into the article buffer.  It is meant to handle all treatment
  292. of the article before it is displayed.
  293.  
  294.    By default this hook just contains `gnus-article-hide-headers',
  295. `gnus-article-treat-overstrike', and `gnus-article-maybe-highlight',
  296. but there are thousands, nay millions, of functions you can put in this
  297. hook.  For an overview of functions *note Article Highlighting::.,
  298. *note Article Hiding::., *note Article Washing::., *note Article
  299. Buttons::. and *note Article Date::..  Note that the order of functions
  300. in this hook might affect things, so you may have to fiddle a bit to
  301. get the desired results.
  302.  
  303.    You can, of course, write your own functions.  The functions are
  304. called from the article buffer, and you can do anything you like,
  305. pretty much.  There is no information that you have to keep in the
  306. buffer--you can change everything.  However, you shouldn't delete any
  307. headers.  Instead make them invisible if you want to make them go away.
  308.  
  309. 
  310. File: gnus.info,  Node: Article Keymap,  Next: Misc Article,  Prev: Customizing Articles,  Up: The Article Buffer
  311.  
  312. Article Keymap
  313. ==============
  314.  
  315.    Most of the keystrokes in the summary buffer can also be used in the
  316. article buffer.  They should behave as if you typed them in the summary
  317. buffer, which means that you don't actually have to have a summary
  318. buffer displayed while reading.  You can do it all from the article
  319. buffer.
  320.  
  321.    A few additional keystrokes are available:
  322.  
  323. `SPACE'
  324.      Scroll forwards one page (`gnus-article-next-page').
  325.  
  326. `DEL'
  327.      Scroll backwards one page (`gnus-article-prev-page').
  328.  
  329. `C-c ^'
  330.      If point is in the neighborhood of a `Message-ID' and you press
  331.      `r', Gnus will try to get that article from the server
  332.      (`gnus-article-refer-article').
  333.  
  334. `C-c C-m'
  335.      Send a reply to the address near point (`gnus-article-mail').  If
  336.      given a prefix, include the mail.
  337.  
  338. `s'
  339.      Reconfigure the buffers so that the summary buffer becomes visible
  340.      (`gnus-article-show-summary').
  341.  
  342. `?'
  343.      Give a very brief description of the available keystrokes
  344.      (`gnus-article-describe-briefly').
  345.  
  346. `TAB'
  347.      Go to the next button, if any (`gnus-article-next-button').  This
  348.      only makes sense if you have buttonizing turned on.
  349.  
  350. `M-TAB'
  351.      Go to the previous button, if any (`gnus-article-prev-button').
  352.  
  353. 
  354. File: gnus.info,  Node: Misc Article,  Prev: Article Keymap,  Up: The Article Buffer
  355.  
  356. Misc Article
  357. ============
  358.  
  359. `gnus-single-article-buffer'
  360.      If non-`nil', use the same article buffer for all the groups.
  361.      (This is the default.)  If `nil', each group will have its own
  362.      article buffer.
  363.  
  364. `gnus-article-prepare-hook'
  365.      This hook is called right after the article has been inserted into
  366.      the article buffer.  It is mainly intended for functions that do
  367.      something depending on the contents; it should probably not be
  368.      used for changing the contents of the article buffer.
  369.  
  370. `gnus-article-display-hook'
  371.      This hook is called as the last thing when displaying an article,
  372.      and is intended for modifying the contents of the buffer, doing
  373.      highlights, hiding headers, and the like.
  374.  
  375. `gnus-article-mode-hook'
  376.      Hook called in article mode buffers.
  377.  
  378. `gnus-article-mode-syntax-table'
  379.      Syntax table used in article buffers.  It is initialized from
  380.      `text-mode-syntax-table'.
  381.  
  382. `gnus-article-mode-line-format'
  383.      This variable is a format string along the same lines as
  384.      `gnus-summary-mode-line-format'.  It accepts the same format
  385.      specifications as that variable, with one extension:
  386.  
  387.     `w'
  388.           The "wash status" of the article.  This is a short string
  389.           with one character for each possible article wash operation
  390.           that may have been performed.
  391.  
  392. `gnus-break-pages'
  393.      Controls whether "page breaking" is to take place.  If this
  394.      variable is non-`nil', the articles will be divided into pages
  395.      whenever a page delimiter appears in the article.  If this
  396.      variable is `nil', paging will not be done.
  397.  
  398. `gnus-page-delimiter'
  399.      This is the delimiter mentioned above.  By default, it is `^L'
  400.      (formfeed).
  401.  
  402. 
  403. File: gnus.info,  Node: Composing Messages,  Next: Select Methods,  Prev: The Article Buffer,  Up: Top
  404.  
  405. Composing Messages
  406. ******************
  407.  
  408.    All commands for posting and mailing will put you in a message buffer
  409. where you can edit the article all you like, before you send the article
  410. by pressing `C-c C-c'.  *Note Top: (message)Top.  If you are in a
  411. foreign news group, and you wish to post the article using the foreign
  412. server, you can give a prefix to `C-c C-c' to make Gnus try to post
  413. using the foreign server.
  414.  
  415. * Menu:
  416.  
  417. * Mail::                 Mailing and replying.
  418. * Post::                 Posting and following up.
  419. * Posting Server::       What server should you post via?
  420. * Mail and Post::        Mailing and posting at the same time.
  421. * Archived Messages::    Where Gnus stores the messages you've sent.
  422.  
  423.    Also see *note Canceling and Superseding::. for information on how to
  424. remove articles you shouldn't have posted.
  425.  
  426. 
  427. File: gnus.info,  Node: Mail,  Next: Post,  Up: Composing Messages
  428.  
  429. Mail
  430. ====
  431.  
  432.    Variables for customizing outgoing mail:
  433.  
  434. `gnus-uu-digest-headers'
  435.      List of regexps to match headers included in digested messages.
  436.      The headers will be included in the sequence they are matched.
  437.  
  438. `gnus-add-to-list'
  439.      If non-`nil', add a `to-list' group parameter to mail groups that
  440.      have none when you do a `a'.
  441.  
  442. 
  443. File: gnus.info,  Node: Post,  Next: Posting Server,  Prev: Mail,  Up: Composing Messages
  444.  
  445. Post
  446. ====
  447.  
  448.    Variables for composing news articles:
  449.  
  450. `gnus-sent-message-ids-file'
  451.      Gnus will keep a `Message-ID' history file of all the mails it has
  452.      sent.  If it discovers that it has already sent a mail, it will
  453.      ask the user whether to re-send the mail.  (This is primarily
  454.      useful when dealing with SOUP packets and the like where one is
  455.      apt to send the same packet multiple times.)  This variable says
  456.      what the name of this history file is.  It is
  457.      `~/News/Sent-Message-IDs' by default.  Set this variable to `nil'
  458.      if you don't want Gnus to keep a history file.
  459.  
  460. `gnus-sent-message-ids-length'
  461.      This variable says how many `Message-ID's to keep in the history
  462.      file.  It is 1000 by default.
  463.  
  464. 
  465. File: gnus.info,  Node: Posting Server,  Next: Mail and Post,  Prev: Post,  Up: Composing Messages
  466.  
  467. Posting Server
  468. ==============
  469.  
  470.    When you press those magical `C-c C-c' keys to ship off your latest
  471. (extremely intelligent, of course) article, where does it go?
  472.  
  473.    Thank you for asking.  I hate you.
  474.  
  475.    It can be quite complicated.  Normally, Gnus will use the same native
  476. server.  However.  If your native server doesn't allow posting, just
  477. reading, you probably want to use some other server to post your
  478. (extremely intelligent and fabulously interesting) articles.  You can
  479. then set the `gnus-post-method' to some other method:
  480.  
  481.      (setq gnus-post-method '(nnspool ""))
  482.  
  483.    Now, if you've done this, and then this server rejects your article,
  484. or this server is down, what do you do then?  To override this variable
  485. you can use a non-zero prefix to the `C-c C-c' command to force using
  486. the "current" server for posting.
  487.  
  488.    If you give a zero prefix (i.e., `C-u 0 C-c C-c') to that command,
  489. Gnus will prompt you for what method to use for posting.
  490.  
  491.    You can also set `gnus-post-method' to a list of select methods.  If
  492. that's the case, Gnus will always prompt you for what method to use for
  493. posting.
  494.  
  495. 
  496. File: gnus.info,  Node: Mail and Post,  Next: Archived Messages,  Prev: Posting Server,  Up: Composing Messages
  497.  
  498. Mail and Post
  499. =============
  500.  
  501.    Here's a list of variables relevant to both mailing and posting:
  502.  
  503. `gnus-mailing-list-groups'
  504.      If your news server offers groups that are really mailing lists
  505.      gatewayed to the NNTP server, you can read those groups without
  506.      problems, but you can't post/followup to them without some
  507.      difficulty.  One solution is to add a `to-address' to the group
  508.      parameters (*note Group Parameters::.).  An easier thing to do is
  509.      set the `gnus-mailing-list-groups' to a regexp that matches the
  510.      groups that really are mailing lists.  Then, at least, followups
  511.      to the mailing lists will work most of the time.  Posting to these
  512.      groups (`a') is still a pain, though.
  513.  
  514.    You may want to do spell-checking on messages that you send out.
  515. Or, if you don't want to spell-check by hand, you could add automatic
  516. spell-checking via the `ispell' package:
  517.  
  518.      (add-hook 'message-send-hook 'ispell-message)
  519.  
  520. 
  521. File: gnus.info,  Node: Archived Messages,  Prev: Mail and Post,  Up: Composing Messages
  522.  
  523. Archived Messages
  524. =================
  525.  
  526.    Gnus provides a few different methods for storing the mail and news
  527. you send.  The default method is to use the "archive virtual server" to
  528. store the messages.  If you want to disable this completely, the
  529. `gnus-message-archive-group' variable should be `nil', which is the
  530. default.
  531.  
  532.    `gnus-message-archive-method' says what virtual server Gnus is to
  533. use to store sent messages.  The default is:
  534.  
  535.      (nnfolder "archive"
  536.                (nnfolder-directory "~/Mail/archive/"))
  537.  
  538.    You can, however, use any mail select method (`nnml', `nnmbox',
  539. etc.).  `nnfolder' is a quite likeable select method for doing this
  540. sort of thing, though.  If you don't like the default directory chosen,
  541. you could say something like:
  542.  
  543.      (setq gnus-message-archive-method
  544.            '(nnfolder "archive"
  545.                       (nnfolder-inhibit-expiry t)
  546.                       (nnfolder-active-file "~/News/sent-mail/active")
  547.                       (nnfolder-directory "~/News/sent-mail/")))
  548.  
  549.    Gnus will insert `Gcc' headers in all outgoing messages that point
  550. to one or more group(s) on that server.  Which group to use is
  551. determined by the `gnus-message-archive-group' variable.
  552.  
  553.    This variable can be used to do the following:
  554.  
  555.    * a string Messages will be saved in that group.
  556.  
  557.    * a list of strings Messages will be saved in all those groups.
  558.  
  559.    * an alist of regexps, functions and forms When a key "matches", the
  560.      result is used.
  561.  
  562.    * `nil' No message archiving will take place.  This is the default.
  563.  
  564.    Let's illustrate:
  565.  
  566.    Just saving to a single group called `MisK':
  567.      (setq gnus-message-archive-group "MisK")
  568.  
  569.    Saving to two groups, `MisK' and `safe':
  570.      (setq gnus-message-archive-group '("MisK" "safe"))
  571.  
  572.    Save to different groups based on what group you are in:
  573.      (setq gnus-message-archive-group
  574.            '(("^alt" "sent-to-alt")
  575.              ("mail" "sent-to-mail")
  576.              (".*" "sent-to-misc")))
  577.  
  578.    More complex stuff:
  579.      (setq gnus-message-archive-group
  580.            '((if (message-news-p)
  581.                  "misc-news"
  582.                "misc-mail")))
  583.  
  584.    How about storing all news messages in one file, but storing all mail
  585. messages in one file per month:
  586.  
  587.      (setq gnus-message-archive-group
  588.            '((if (message-news-p)
  589.                  "misc-news"
  590.                (concat "mail." (format-time-string
  591.                                 "%Y-%m" (current-time))))))
  592.  
  593.    (XEmacs 19.13 doesn't have `format-time-string', so you'll have to
  594. use a different value for `gnus-message-archive-group' there.)
  595.  
  596.    Now, when you send a message off, it will be stored in the
  597. appropriate group.  (If you want to disable storing for just one
  598. particular message, you can just remove the `Gcc' header that has been
  599. inserted.)  The archive group will appear in the group buffer the next
  600. time you start Gnus, or the next time you press `F' in the group
  601. buffer.  You can enter it and read the articles in it just like you'd
  602. read any other group.  If the group gets really big and annoying, you
  603. can simply rename if (using `G r' in the group buffer) to something
  604. nice--`misc-mail-september-1995', or whatever.  New messages will
  605. continue to be stored in the old (now empty) group.
  606.  
  607.    That's the default method of archiving sent messages.  Gnus offers a
  608. different way for the people who don't like the default method.  In that
  609. case you should set `gnus-message-archive-group' to `nil'; this will
  610. disable archiving.
  611.  
  612. `gnus-outgoing-message-group'
  613.      All outgoing messages will be put in this group.  If you want to
  614.      store all your outgoing mail and articles in the group
  615.      `nnml:archive', you set this variable to that value.  This
  616.      variable can also be a list of group names.
  617.  
  618.      If you want to have greater control over what group to put each
  619.      message in, you can set this variable to a function that checks the
  620.      current newsgroup name and then returns a suitable group name (or
  621.      list of names).
  622.  
  623.      This variable can be used instead of `gnus-message-archive-group',
  624.      but the latter is the preferred method.
  625.  
  626. 
  627. File: gnus.info,  Node: Select Methods,  Next: Scoring,  Prev: Composing Messages,  Up: Top
  628.  
  629. Select Methods
  630. **************
  631.  
  632.    A "foreign group" is a group not read by the usual (or default)
  633. means.  It could be, for instance, a group from a different NNTP
  634. server, it could be a virtual group, or it could be your own personal
  635. mail group.
  636.  
  637.    A foreign group (or any group, really) is specified by a "name" and
  638. a "select method".  To take the latter first, a select method is a list
  639. where the first element says what backend to use (e.g. `nntp',
  640. `nnspool', `nnml') and the second element is the "server name".  There
  641. may be additional elements in the select method, where the value may
  642. have special meaning for the backend in question.
  643.  
  644.    One could say that a select method defines a "virtual server"--so we
  645. do just that (*note The Server Buffer::.).
  646.  
  647.    The "name" of the group is the name the backend will recognize the
  648. group as.
  649.  
  650.    For instance, the group `soc.motss' on the NNTP server
  651. `some.where.edu' will have the name `soc.motss' and select method
  652. `(nntp "some.where.edu")'.  Gnus will call this group
  653. `nntp+some.where.edu:soc.motss', even though the `nntp' backend just
  654. knows this group as `soc.motss'.
  655.  
  656.    The different methods all have their peculiarities, of course.
  657.  
  658. * Menu:
  659.  
  660. * The Server Buffer::     Making and editing virtual servers.
  661. * Getting News::          Reading USENET news with Gnus.
  662. * Getting Mail::          Reading your personal mail with Gnus.
  663. * Other Sources::         Reading directories, files, SOUP packets.
  664. * Combined Groups::       Combining groups into one group.
  665.  
  666. 
  667. File: gnus.info,  Node: The Server Buffer,  Next: Getting News,  Up: Select Methods
  668.  
  669. The Server Buffer
  670. =================
  671.  
  672.    Traditionally, a "server" is a machine or a piece of software that
  673. one connects to, and then requests information from.  Gnus does not
  674. connect directly to any real servers, but does all transactions through
  675. one backend or other.  But that's just putting one layer more between
  676. the actual media and Gnus, so we might just as well say that each
  677. backend represents a virtual server.
  678.  
  679.    For instance, the `nntp' backend may be used to connect to several
  680. different actual NNTP servers, or, perhaps, to many different ports on
  681. the same actual NNTP server.  You tell Gnus which backend to use, and
  682. what parameters to set by specifying a "select method".
  683.  
  684.    These select method specifications can sometimes become quite
  685. complicated--say, for instance, that you want to read from the NNTP
  686. server `news.funet.fi' on port number 13, which hangs if queried for
  687. NOV headers and has a buggy select.  Ahem.  Anyways, if you had to
  688. specify that for each group that used this server, that would be too
  689. much work, so Gnus offers a way of naming select methods, which is what
  690. you do in the server buffer.
  691.  
  692.    To enter the server buffer, use the `^'
  693. (`gnus-group-enter-server-mode') command in the group buffer.
  694.  
  695. * Menu:
  696.  
  697. * Server Buffer Format::      You can customize the look of this buffer.
  698. * Server Commands::           Commands to manipulate servers.
  699. * Example Methods::           Examples server specifications.
  700. * Creating a Virtual Server:: An example session.
  701. * Server Variables::          Which variables to set.
  702. * Servers and Methods::       You can use server names as select methods.
  703. * Unavailable Servers::       Some servers you try to contact may be down.
  704.  
  705.    `gnus-server-mode-hook' is run when creating the server buffer.
  706.  
  707. 
  708. File: gnus.info,  Node: Server Buffer Format,  Next: Server Commands,  Up: The Server Buffer
  709.  
  710. Server Buffer Format
  711. --------------------
  712.  
  713.    You can change the look of the server buffer lines by changing the
  714. `gnus-server-line-format' variable.  This is a `format'-like variable,
  715. with some simple extensions:
  716.  
  717. `h'
  718.      How the news is fetched--the backend name.
  719.  
  720. `n'
  721.      The name of this server.
  722.  
  723. `w'
  724.      Where the news is to be fetched from--the address.
  725.  
  726. `s'
  727.      The opened/closed/denied status of the server.
  728.  
  729.    The mode line can also be customized by using the
  730. `gnus-server-mode-line-format' variable.  The following specs are
  731. understood:
  732.  
  733. `S'
  734.      Server name.
  735.  
  736. `M'
  737.      Server method.
  738.  
  739.    Also *note Formatting Variables::..
  740.  
  741. 
  742. File: gnus.info,  Node: Server Commands,  Next: Example Methods,  Prev: Server Buffer Format,  Up: The Server Buffer
  743.  
  744. Server Commands
  745. ---------------
  746.  
  747. `a'
  748.      Add a new server (`gnus-server-add-server').
  749.  
  750. `e'
  751.      Edit a server (`gnus-server-edit-server').
  752.  
  753. `SPACE'
  754.      Browse the current server (`gnus-server-read-server').
  755.  
  756. `q'
  757.      Return to the group buffer (`gnus-server-exit').
  758.  
  759. `k'
  760.      Kill the current server (`gnus-server-kill-server').
  761.  
  762. `y'
  763.      Yank the previously killed server (`gnus-server-yank-server').
  764.  
  765. `c'
  766.      Copy the current server (`gnus-server-copy-server').
  767.  
  768. `l'
  769.      List all servers (`gnus-server-list-servers').
  770.  
  771. `s'
  772.      Request that the server scan its sources for new articles
  773.      (`gnus-server-scan-server').  This is mainly sensible with mail
  774.      servers.
  775.  
  776. `g'
  777.      Request that the server regenerate all its data structures
  778.      (`gnus-server-regenerate-server').  This can be useful if you have
  779.      a mail backend that has gotten out of synch.
  780.  
  781. 
  782. File: gnus.info,  Node: Example Methods,  Next: Creating a Virtual Server,  Prev: Server Commands,  Up: The Server Buffer
  783.  
  784. Example Methods
  785. ---------------
  786.  
  787.    Most select methods are pretty simple and self-explanatory:
  788.  
  789.      (nntp "news.funet.fi")
  790.  
  791.    Reading directly from the spool is even simpler:
  792.  
  793.      (nnspool "")
  794.  
  795.    As you can see, the first element in a select method is the name of
  796. the backend, and the second is the "address", or "name", if you will.
  797.  
  798.    After these two elements, there may be an arbitrary number of
  799. (VARIABLE FORM) pairs.
  800.  
  801.    To go back to the first example--imagine that you want to read from
  802. port 15 on that machine.  This is what the select method should look
  803. like then:
  804.  
  805.      (nntp "news.funet.fi" (nntp-port-number 15))
  806.  
  807.    You should read the documentation to each backend to find out what
  808. variables are relevant, but here's an `nnmh' example:
  809.  
  810.    `nnmh' is a mail backend that reads a spool-like structure.  Say you
  811. have two structures that you wish to access: One is your private mail
  812. spool, and the other is a public one.  Here's the possible spec for
  813. your private mail:
  814.  
  815.      (nnmh "private" (nnmh-directory "~/private/mail/"))
  816.  
  817.    (This server is then called `private', but you may have guessed
  818. that.)
  819.  
  820.    Here's the method for a public spool:
  821.  
  822.      (nnmh "public"
  823.            (nnmh-directory "/usr/information/spool/")
  824.            (nnmh-get-new-mail nil))
  825.  
  826.    If you are behind a firewall and only have access to the NNTP server
  827. from the firewall machine, you can instruct Gnus to `rlogin' on the
  828. firewall machine and telnet from there to the NNTP server.  Doing this
  829. can be rather fiddly, but your virtual server definition should
  830. probably look something like this:
  831.  
  832.      (nntp "firewall"
  833.            (nntp-address "the.firewall.machine")
  834.            (nntp-open-connection-function nntp-open-rlogin)
  835.            (nntp-end-of-line "\n")
  836.            (nntp-rlogin-parameters
  837.             ("telnet" "the.real.nntp.host" "nntp")))
  838.  
  839. 
  840. File: gnus.info,  Node: Creating a Virtual Server,  Next: Server Variables,  Prev: Example Methods,  Up: The Server Buffer
  841.  
  842. Creating a Virtual Server
  843. -------------------------
  844.  
  845.    If you're saving lots of articles in the cache by using persistent
  846. articles, you may want to create a virtual server to read the cache.
  847.  
  848.    First you need to add a new server.  The `a' command does that.  It
  849. would probably be best to use `nnspool' to read the cache.  You could
  850. also use `nnml' or `nnmh', though.
  851.  
  852.    Type `a nnspool RET cache RET'.
  853.  
  854.    You should now have a brand new `nnspool' virtual server called
  855. `cache'.  You now need to edit it to have the right definitions.  Type
  856. `e' to edit the server.  You'll be entered into a buffer that will
  857. contain the following:
  858.  
  859.      (nnspool "cache")
  860.  
  861.    Change that to:
  862.  
  863.      (nnspool "cache"
  864.               (nnspool-spool-directory "~/News/cache/")
  865.               (nnspool-nov-directory "~/News/cache/")
  866.               (nnspool-active-file "~/News/cache/active"))
  867.  
  868.    Type `C-c C-c' to return to the server buffer.  If you now press
  869. `RET' over this virtual server, you should be entered into a browse
  870. buffer, and you should be able to enter any of the groups displayed.
  871.  
  872. 
  873. File: gnus.info,  Node: Server Variables,  Next: Servers and Methods,  Prev: Creating a Virtual Server,  Up: The Server Buffer
  874.  
  875. Server Variables
  876. ----------------
  877.  
  878.    One sticky point when defining variables (both on backends and in
  879. Emacs in general) is that some variables are typically initialized from
  880. other variables when the definition of the variables is being loaded.
  881. If you change the "base" variable after the variables have been loaded,
  882. you won't change the "derived" variables.
  883.  
  884.    This typically affects directory and file variables.  For instance,
  885. `nnml-directory' is `~/Mail/' by default, and all `nnml' directory
  886. variables are initialized from that variable, so `nnml-active-file'
  887. will be `~/Mail/active'.  If you define a new virtual `nnml' server, it
  888. will *not* suffice to set just `nnml-directory'--you have to explicitly
  889. set all the file variables to be what you want them to be.  For a
  890. complete list of variables for each backend, see each backend's section
  891. later in this manual, but here's an example `nnml' definition:
  892.  
  893.      (nnml "public"
  894.            (nnml-directory "~/my-mail/")
  895.            (nnml-active-file "~/my-mail/active")
  896.            (nnml-newsgroups-file "~/my-mail/newsgroups"))
  897.  
  898. 
  899. File: gnus.info,  Node: Servers and Methods,  Next: Unavailable Servers,  Prev: Server Variables,  Up: The Server Buffer
  900.  
  901. Servers and Methods
  902. -------------------
  903.  
  904.    Wherever you would normally use a select method (e.g.
  905. `gnus-secondary-select-method', in the group select method, when
  906. browsing a foreign server) you can use a virtual server name instead.
  907. This could potentially save lots of typing.  And it's nice all over.
  908.  
  909. 
  910. File: gnus.info,  Node: Unavailable Servers,  Prev: Servers and Methods,  Up: The Server Buffer
  911.  
  912. Unavailable Servers
  913. -------------------
  914.  
  915.    If a server seems to be unreachable, Gnus will mark that server as
  916. `denied'.  That means that any subsequent attempt to make contact with
  917. that server will just be ignored.  "It can't be opened," Gnus will tell
  918. you, without making the least effort to see whether that is actually
  919. the case or not.
  920.  
  921.    That might seem quite naughty, but it does make sense most of the
  922. time.  Let's say you have 10 groups subscribed to on server
  923. `nephelococcygia.com'.  This server is located somewhere quite far away
  924. from you and the machine is quite slow, so it takes 1 minute just to
  925. find out that it refuses connection to you today.  If Gnus were to
  926. attempt to do that 10 times, you'd be quite annoyed, so Gnus won't
  927. attempt to do that.  Once it has gotten a single "connection refused",
  928. it will regard that server as "down".
  929.  
  930.    So, what happens if the machine was only feeling unwell temporarily?
  931. How do you test to see whether the machine has come up again?
  932.  
  933.    You jump to the server buffer (*note The Server Buffer::.) and poke
  934. it with the following commands:
  935.  
  936. `O'
  937.      Try to establish connection to the server on the current line
  938.      (`gnus-server-open-server').
  939.  
  940. `C'
  941.      Close the connection (if any) to the server
  942.      (`gnus-server-close-server').
  943.  
  944. `D'
  945.      Mark the current server as unreachable (`gnus-server-deny-server').
  946.  
  947. `M-o'
  948.      Open the connections to all servers in the buffer
  949.      (`gnus-server-open-all-servers').
  950.  
  951. `M-c'
  952.      Close the connections to all servers in the buffer
  953.      (`gnus-server-close-all-servers').
  954.  
  955. `R'
  956.      Remove all marks to whether Gnus was denied connection from any
  957.      servers (`gnus-server-remove-denials').
  958.  
  959. 
  960. File: gnus.info,  Node: Getting News,  Next: Getting Mail,  Prev: The Server Buffer,  Up: Select Methods
  961.  
  962. Getting News
  963. ============
  964.  
  965.    A newsreader is normally used for reading news.  Gnus currently
  966. provides only two methods of getting news--it can read from an NNTP
  967. server, or it can read from a local spool.
  968.  
  969. * Menu:
  970.  
  971. * NNTP::               Reading news from an NNTP server.
  972. * News Spool::         Reading news from the local spool.
  973.  
  974. 
  975. File: gnus.info,  Node: NNTP,  Next: News Spool,  Up: Getting News
  976.  
  977. NNTP
  978. ----
  979.  
  980.    Subscribing to a foreign group from an NNTP server is rather easy.
  981. You just specify `nntp' as method and the address of the NNTP server as
  982. the, uhm, address.
  983.  
  984.    If the NNTP server is located at a non-standard port, setting the
  985. third element of the select method to this port number should allow you
  986. to connect to the right port.  You'll have to edit the group info for
  987. that (*note Foreign Groups::.).
  988.  
  989.    The name of the foreign group can be the same as a native group.  In
  990. fact, you can subscribe to the same group from as many different servers
  991. you feel like.  There will be no name collisions.
  992.  
  993.    The following variables can be used to create a virtual `nntp'
  994. server:
  995.  
  996. `nntp-server-opened-hook'
  997.      is run after a connection has been made.  It can be used to send
  998.      commands to the NNTP server after it has been contacted.  By
  999.      default it sends the command `MODE READER' to the server with the
  1000.      `nntp-send-mode-reader' function.  This function should always be
  1001.      present in this hook.
  1002.  
  1003. `nntp-authinfo-function'
  1004.      This function will be used to send `AUTHINFO' to the NNTP server.
  1005.      Available functions include:
  1006.  
  1007.     `nntp-send-authinfo'
  1008.           This function will use your current login name as the user
  1009.           name and will prompt you for the password.  This is the
  1010.           default.
  1011.  
  1012.     `nntp-send-nosy-authinfo'
  1013.           This function will prompt you for both user name and password.
  1014.  
  1015.     `nntp-send-authinfo-from-file'
  1016.           This function will use your current login name as the user
  1017.           name and will read the NNTP password from `~/.nntp-authinfo'.
  1018.  
  1019. `nntp-server-action-alist'
  1020.      This is a list of regexps to match on server types and actions to
  1021.      be taken when matches are made.  For instance, if you want Gnus to
  1022.      beep every time you connect to innd, you could say something like:
  1023.  
  1024.           (setq nntp-server-action-alist
  1025.                 '(("innd" (ding))))
  1026.  
  1027.      You probably don't want to do that, though.
  1028.  
  1029.      The default value is
  1030.  
  1031.           '(("nntpd 1\\.5\\.11t"
  1032.              (remove-hook 'nntp-server-opened-hook 'nntp-send-mode-reader)))
  1033.  
  1034.      This ensures that Gnus doesn't send the `MODE READER' command to
  1035.      nntpd 1.5.11t, since that command chokes that server, I've been
  1036.      told.
  1037.  
  1038. `nntp-maximum-request'
  1039.      If the NNTP server doesn't support NOV headers, this backend will
  1040.      collect headers by sending a series of `head' commands.  To speed
  1041.      things up, the backend sends lots of these commands without
  1042.      waiting for reply, and then reads all the replies.  This is
  1043.      controlled by the `nntp-maximum-request' variable, and is 400 by
  1044.      default.  If your network is buggy, you should set this to 1.
  1045.  
  1046. `nntp-connection-timeout'
  1047.      If you have lots of foreign `nntp' groups that you connect to
  1048.      regularly, you're sure to have problems with NNTP servers not
  1049.      responding properly, or being too loaded to reply within reasonable
  1050.      time.  This is can lead to awkward problems, which can be helped
  1051.      somewhat by setting `nntp-connection-timeout'.  This is an integer
  1052.      that says how many seconds the `nntp' backend should wait for a
  1053.      connection before giving up.  If it is `nil', which is the default,
  1054.      no timeouts are done.
  1055.  
  1056. `nntp-command-timeout'
  1057.      If you're running Gnus on a machine that has a dynamically assigned
  1058.      address, Gnus may become confused.  If the address of your machine
  1059.      changes after connecting to the NNTP server, Gnus will simply sit
  1060.      waiting forever for replies from the server.  To help with this
  1061.      unfortunate problem, you can set this command to a number.  Gnus
  1062.      will then, if it sits waiting for a reply from the server longer
  1063.      than that number of seconds, shut down the connection, start a new
  1064.      one, and resend the command.  This should hopefully be transparent
  1065.      to the user.  A likely number is 30 seconds.
  1066.  
  1067. `nntp-retry-on-break'
  1068.      If this variable is non-`nil', you can also `C-g' if Gnus hangs.
  1069.      This will have much the same effect as the command timeout
  1070.      described above.
  1071.  
  1072. `nntp-server-hook'
  1073.      This hook is run as the last step when connecting to an NNTP
  1074.      server.
  1075.  
  1076. `nntp-open-connection-function'
  1077.      This function is used to connect to the remote system.  Three
  1078.      pre-made functions are `nntp-open-network-stream', which is the
  1079.      default, and simply connects to some port or other on the remote
  1080.      system.  The other two are `nntp-open-rlogin', which does an
  1081.      `rlogin' on the remote system, and then does a `telnet' to the
  1082.      NNTP server available there, and `nntp-open-telnet', which does a
  1083.      `telnet' to the remote system and then another `telnet' to get to
  1084.      the NNTP server.
  1085.  
  1086.      `nntp-open-rlogin'-related variables:
  1087.  
  1088.     `nntp-rlogin-parameters'
  1089.           This list will be used as the parameter list given to `rsh'.
  1090.  
  1091.     `nntp-rlogin-user-name'
  1092.           User name on the remote system.
  1093.  
  1094.      `nntp-open-telnet'-related variables:
  1095.  
  1096.     `nntp-telnet-command'
  1097.           Command used to start `telnet'.
  1098.  
  1099.     `nntp-telnet-switches'
  1100.           List of strings to be used as the switches to the `telnet'
  1101.           command.
  1102.  
  1103.     `nntp-telnet-user-name'
  1104.           User name for log in on the remote system.
  1105.  
  1106.     `nntp-telnet-passwd'
  1107.           Password to use when logging in.
  1108.  
  1109.     `nntp-telnet-parameters'
  1110.           A list of strings executed as a command after logging in via
  1111.           `telnet'.
  1112.  
  1113. `nntp-end-of-line'
  1114.      String to use as end-of-line marker when talking to the NNTP
  1115.      server.  This is `\r\n' by default, but should be `\n' when using
  1116.      `rlogin' to talk to the server.
  1117.  
  1118. `nntp-rlogin-user-name'
  1119.      User name on the remote system when using the `rlogin' connect
  1120.      function.
  1121.  
  1122. `nntp-address'
  1123.      The address of the remote system running the NNTP server.
  1124.  
  1125. `nntp-port-number'
  1126.      Port number to connect to when using the `nntp-open-network-stream'
  1127.      connect function.
  1128.  
  1129. `nntp-buggy-select'
  1130.      Set this to non-`nil' if your select routine is buggy.
  1131.  
  1132. `nntp-nov-is-evil'
  1133.      If the NNTP server does not support NOV, you could set this
  1134.      variable to `t', but `nntp' usually checks automatically whether
  1135.      NOV can be used.
  1136.  
  1137. `nntp-xover-commands'
  1138.      List of strings used as commands to fetch NOV lines from a server.
  1139.      The default value of this variable is `("XOVER" "XOVERVIEW")'.
  1140.  
  1141. `nntp-nov-gap'
  1142.      `nntp' normally sends just one big request for NOV lines to the
  1143.      server.  The server responds with one huge list of lines.  However,
  1144.      if you have read articles 2-5000 in the group, and only want to
  1145.      read article 1 and 5001, that means that `nntp' will fetch 4999 NOV
  1146.      lines that you will not need.  This variable says how big a gap
  1147.      between two consecutive articles is allowed to be before the
  1148.      `XOVER' request is split into several request.  Note that if your
  1149.      network is fast, setting this variable to a really small number
  1150.      means that fetching will probably be slower.  If this variable is
  1151.      `nil', `nntp' will never split requests.  The default is 5.
  1152.  
  1153. `nntp-prepare-server-hook'
  1154.      A hook run before attempting to connect to an NNTP server.
  1155.  
  1156. `nntp-warn-about-losing-connection'
  1157.      If this variable is non-`nil', some noise will be made when a
  1158.      server closes connection.
  1159.  
  1160. 
  1161. File: gnus.info,  Node: News Spool,  Prev: NNTP,  Up: Getting News
  1162.  
  1163. News Spool
  1164. ----------
  1165.  
  1166.    Subscribing to a foreign group from the local spool is extremely
  1167. easy, and might be useful, for instance, to speed up reading groups that
  1168. contain very big articles--`alt.binaries.pictures.furniture', for
  1169. instance.
  1170.  
  1171.    Anyways, you just specify `nnspool' as the method and `' (or
  1172. anything else) as the address.
  1173.  
  1174.    If you have access to a local spool, you should probably use that as
  1175. the native select method (*note Finding the News::.).  It is normally
  1176. faster than using an `nntp' select method, but might not be.  It
  1177. depends.  You just have to try to find out what's best at your site.
  1178.  
  1179. `nnspool-inews-program'
  1180.      Program used to post an article.
  1181.  
  1182. `nnspool-inews-switches'
  1183.      Parameters given to the inews program when posting an article.
  1184.  
  1185. `nnspool-spool-directory'
  1186.      Where `nnspool' looks for the articles.  This is normally
  1187.      `/usr/spool/news/'.
  1188.  
  1189. `nnspool-nov-directory'
  1190.      Where `nnspool' will look for NOV files.  This is normally
  1191.      `/usr/spool/news/over.view/'.
  1192.  
  1193. `nnspool-lib-dir'
  1194.      Where the news lib dir is (`/usr/lib/news/' by default).
  1195.  
  1196. `nnspool-active-file'
  1197.      The path to the active file.
  1198.  
  1199. `nnspool-newsgroups-file'
  1200.      The path to the group descriptions file.
  1201.  
  1202. `nnspool-history-file'
  1203.      The path to the news history file.
  1204.  
  1205. `nnspool-active-times-file'
  1206.      The path to the active date file.
  1207.  
  1208. `nnspool-nov-is-evil'
  1209.      If non-`nil', `nnspool' won't try to use any NOV files that it
  1210.      finds.
  1211.  
  1212. `nnspool-sift-nov-with-sed'
  1213.      If non-`nil', which is the default, use `sed' to get the relevant
  1214.      portion from the overview file.  If nil, `nnspool' will load the
  1215.      entire file into a buffer and process it there.
  1216.  
  1217. 
  1218. File: gnus.info,  Node: Getting Mail,  Next: Other Sources,  Prev: Getting News,  Up: Select Methods
  1219.  
  1220. Getting Mail
  1221. ============
  1222.  
  1223.    Reading mail with a newsreader--isn't that just plain WeIrD? But of
  1224. course.
  1225.  
  1226. * Menu:
  1227.  
  1228. * Getting Started Reading Mail:: A simple cookbook example.
  1229. * Splitting Mail::               How to create mail groups.
  1230. * Mail Backend Variables::       Variables for customizing mail handling.
  1231. * Fancy Mail Splitting::         Gnus can do hairy splitting of incoming mail.
  1232. * Mail and Procmail::            Reading mail groups that procmail create.
  1233. * Incorporating Old Mail::       What about the old mail you have?
  1234. * Expiring Mail::                Getting rid of unwanted mail.
  1235. * Washing Mail::                 Removing gruft from the mail you get.
  1236. * Duplicates::                   Dealing with duplicated mail.
  1237. * Not Reading Mail::             Using mail backends for reading other files.
  1238. * Choosing a Mail Backend::      Gnus can read a variety of mail formats.
  1239.  
  1240. 
  1241. File: gnus.info,  Node: Getting Started Reading Mail,  Next: Splitting Mail,  Up: Getting Mail
  1242.  
  1243. Getting Started Reading Mail
  1244. ----------------------------
  1245.  
  1246.    It's quite easy to use Gnus to read your new mail.  You just plonk
  1247. the mail backend of your choice into `gnus-secondary-select-methods',
  1248. and things will happen automatically.
  1249.  
  1250.    For instance, if you want to use `nnml' (which is a "one file per
  1251. mail" backend), you could put the following in your `.gnus' file:
  1252.  
  1253.      (setq gnus-secondary-select-methods
  1254.            '((nnml "private")))
  1255.  
  1256.    Now, the next time you start Gnus, this backend will be queried for
  1257. new articles, and it will move all the messages in your spool file to
  1258. its directory, which is `~/Mail/' by default.  The new group that will
  1259. be created (`mail.misc') will be subscribed, and you can read it like
  1260. any other group.
  1261.  
  1262.    You will probably want to split the mail into several groups, though:
  1263.  
  1264.      (setq nnmail-split-methods
  1265.            '(("junk" "^From:.*Lars Ingebrigtsen")
  1266.             ("crazy" "^Subject:.*die\\|^Organization:.*flabby")
  1267.             ("other" "")))
  1268.  
  1269.    This will result in three new `nnml' mail groups being created:
  1270. `nnml:junk', `nnml:crazy', and `nnml:other'.  All the mail that doesn't
  1271. fit into the first two groups will be placed in the last group.
  1272.  
  1273.    This should be sufficient for reading mail with Gnus.  You might
  1274. want to give the other sections in this part of the manual a perusal,
  1275. though.  Especially *note Choosing a Mail Backend::. and *note Expiring
  1276. Mail::..
  1277.  
  1278.